home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Think Class Libraries / TP TCL->CW TCL v1.1.2.3 / UPI ƒ / Updated UPIs ƒ / fenv.p < prev    next >
Text File  |  1996-02-07  |  11KB  |  266 lines
  1. {
  2.      File:        fenv.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Pascal, July 8, 1994 
  8.     
  9.     Note:        The following file was hand converted from fenv.h
  10.                 See fenv.h for more information and comments.
  11. }
  12.  
  13. {$IFC UNDEFINED UsingIncludes}
  14. {$SETC UsingIncludes := 0}
  15. {$ENDC}
  16.  
  17. {$IFC NOT UsingIncludes}
  18.  UNIT fenv;
  19.  INTERFACE
  20. {$ENDC}
  21.  
  22. {$IFC UNDEFINED __FENV__}
  23. {$SETC __FENV__ := 1}
  24.  
  25. {$I+}
  26. {$SETC fpenvIncludes := UsingIncludes}
  27. {$SETC UsingIncludes := 1}
  28.  
  29. {$IFC UNDEFINED __TYPES__}
  30. {$I Types.p}
  31. {$ENDC}
  32.  
  33.  
  34. {$IFC GENERATINGPOWERPC }
  35. TYPE
  36. {   fenv_t is a type for representing the entire floating-point
  37.       environment in a single object.                                         }
  38.  
  39.     fenv_t = LONGINT;
  40.  
  41. {   fexcept_t is a type for representing the floating-point
  42.       exception flag state collectively.                                      }
  43.  
  44.     fexcept_t = LONGINT;
  45.  
  46. CONST
  47. {    Definitions of floating-point exception macros                          }
  48.  
  49.     FE_INEXACT         = $02000000;       {     inexact              }
  50.     FE_DIVBYZERO       = $04000000;       {     divide-by-zero       }
  51.     FE_UNDERFLOW       = $08000000;       {     underflow            }
  52.     FE_OVERFLOW        = $10000000;       {     overflow             }
  53.     FE_INVALID         = $20000000;       {     invlalid             }
  54.  
  55. {   Definitions of rounding direction macros                                }
  56.  
  57.     FE_TONEAREST       = $00000000;
  58.     FE_TOWARDZERO      = $00000001;
  59.     FE_UPWARD          = $00000002;
  60.     FE_DOWNWARD        = $00000003;
  61.     
  62. {$ELSEC}
  63.  
  64. CONST
  65.     FE_TONEAREST       = $0000;
  66.     FE_UPWARD          = $0001;
  67.     FE_DOWNWARD        = $0002;
  68.     FE_TOWARDZERO      = $0003;
  69.     
  70. {   Definitions of rounding precision macros  (68K only)                    }
  71.  
  72.     FE_LDBLPREC        = $0000;
  73.     FE_DBLPREC         = $0001;
  74.     FE_FLTPREC         = $0002;
  75.  
  76.     {$IFC OPTION(mc68881) }
  77.     TYPE
  78.         fenv_t =     RECORD
  79.                         FPCR: LONGINT;
  80.                         FPSR: LONGINT;
  81.                     END;
  82.         fexcept_t = LONGINT;
  83.         
  84.     CONST
  85.         FE_INEXACT         = $00000008;  
  86.         FE_DIVBYZERO       = $00000010;     
  87.         FE_UNDERFLOW       = $00000020;    
  88.         FE_OVERFLOW        = $00000040;      
  89.         FE_INVALID         = $00000080;   
  90.     
  91.     {$ELSEC}
  92.     TYPE
  93.         fenv_t    = INTEGER;
  94.         fexcept_t = INTEGER;
  95.     CONST
  96.         FE_INVALID         = $0001;   
  97.         FE_UNDERFLOW       = $0002;    
  98.         FE_OVERFLOW        = $0004;      
  99.         FE_DIVBYZERO       = $0008;     
  100.         FE_INEXACT         = $0010;  
  101.     {$ENDC}
  102.     
  103. {$ENDC}
  104.  
  105.  
  106. {   The bitwise OR of all exception macros                                  }
  107.  
  108.     FE_ALL_EXCEPT  =   FE_INEXACT + FE_DIVBYZERO + FE_UNDERFLOW + FE_OVERFLOW + FE_INVALID;
  109.  
  110.  
  111. {   Definition of pointer to IEEE default environment object                }
  112. VAR
  113.     {$PUSH}
  114.     {$J+}
  115.     _FE_DFL_ENV: fenv_t;   {default environment object        }
  116.     {$POP}
  117.  
  118.  
  119.  
  120. (******************************************************************************
  121. *     The following functions provide access to the exception flags.  The      *
  122. *     "int" input argument can be constructed by bitwise ORs of the exception  *
  123. *     macros: for example: FE_OVERFLOW | FE_INEXACT.                           *
  124. *******************************************************************************)
  125.  
  126. (*******************************************************************************
  127. *     The function "feclearexcept" clears the supported exceptions represented *
  128. *     by its argument.                                                         *
  129. *******************************************************************************)
  130.  
  131. { NB PROCEDURE feclearexcept( excepts: LONGINT ); C; }
  132. PROCEDURE feclearexcept( excepts: LONGINT ); C; EXTERNAL;
  133.  
  134. (*******************************************************************************
  135. *    The function "fegetexcept" stores a representation of the exception       *
  136. *     flags indicated by the argument "excepts" through the pointer argument   *
  137. *     "flagp".                                                                 *
  138. *******************************************************************************)
  139.  
  140. {NB PROCEDURE fegetexcept(VAR flagp: fexcept_t; excepts: LONGINT); C;}
  141. PROCEDURE fegetexcept(VAR flagp: fexcept_t; excepts: LONGINT); C; EXTERNAL;
  142.  
  143. (*******************************************************************************
  144. *     The function "feraiseexcept" raises the supported exceptions             *
  145. *     represented by its argument.                                             *
  146. *******************************************************************************)
  147.  
  148. {NB PROCEDURE feraiseexcept( excepts:    LONGINT ); C; }
  149. PROCEDURE feraiseexcept( excepts:    LONGINT ); C; EXTERNAL;
  150.  
  151. (*******************************************************************************
  152. *     The function "fesetexcept" sets or clears the exception flags indicated  *
  153. *     by the int argument "excepts" according to the representation in the     *
  154. *     object pointed to by the pointer argument "flagp".  The value of         *
  155. *     "*flagp" must have been set by a previous call to "fegetexcept".         *
  156. *     This function does not raise exceptions; it just sets the state of       *
  157. *     the flags.                                                               *
  158. *******************************************************************************)
  159.  
  160. { NB PROCEDURE fesetexcept( VAR flagp:  fexcept_t; excepts:    LONGINT ); C;}
  161. PROCEDURE fesetexcept( VAR flagp:  fexcept_t; excepts:    LONGINT ); C; EXTERNAL;
  162.  
  163. (*******************************************************************************
  164. *     The function "fetestexcept" determines which of the specified subset of  *
  165. *     the exception flags are currently set.  The argument "excepts" specifies *
  166. *     the exception flags to be queried as a bitwise OR of the exception       *
  167. *     macros.  This function returns the bitwise OR of the exception macros    *
  168. *     corresponding to the currently set exceptions included in "excepts".     *
  169. *******************************************************************************)
  170.  
  171. {NB FUNCTION fetestexcept( excepts: LONGINT ): LONGINT; C;}
  172. FUNCTION fetestexcept( excepts: LONGINT ): LONGINT; C; EXTERNAL;
  173.  
  174. (*******************************************************************************
  175. *     The following functions provide control of rounding direction modes.     *
  176. *******************************************************************************)
  177.  
  178. (*******************************************************************************
  179. *     The function "fegetround" returns the value of the rounding direction    *
  180. *     macro which represents the current rounding direction.                   *
  181. *******************************************************************************)
  182.  
  183. {NB FUNCTION fegetround: LONGINT; C;}
  184. FUNCTION fegetround: LONGINT; C; EXTERNAL;
  185.  
  186. (*******************************************************************************
  187. *     The function "fesetround" establishes the rounding direction represented *
  188. *     by its argument.  It returns nonzero if and only if the argument matches *
  189. *     a rounding direction macro.  If not, the rounding direction is not       *
  190. *     changed.                                                                 *
  191. *******************************************************************************)
  192.  
  193. {NB FUNCTION fesetround(round: LONGINT): LONGINT; C;}
  194. FUNCTION fesetround(round: LONGINT): LONGINT; C; EXTERNAL;
  195.  
  196. (*******************************************************************************
  197. *    The following functions manage the floating-point environment, exception  *
  198. *    flags and dynamic modes, as one entity.                                   *
  199. *******************************************************************************)
  200.  
  201. (*******************************************************************************
  202. *     The function "fegetenv" stores the current floating-point environment    *
  203. *     in the object pointed to by its pointer argument "envp".                 *
  204. *******************************************************************************)
  205.  
  206. {NB PROCEDURE fegetenv( VAR envp:    fenv_t ); C;}
  207. PROCEDURE fegetenv( VAR envp:    fenv_t ); C; EXTERNAL;
  208.  
  209. (*******************************************************************************
  210. *     The function "feholdexcept" saves the current environment in the object  *
  211. *     pointed to by its pointer argument "envp", clears the exception flags,   *
  212. *     and clears floating-point exception enables.  This function supersedes   *
  213. *     the SANE function "procentry", but it does not change the current        *
  214. *     rounding direction mode.                                                 *
  215. *******************************************************************************)
  216.  
  217. { NB FUNCTION feholdexcept( VAR envp: fenv_t ): LONGINT; C;}
  218. FUNCTION feholdexcept( VAR envp: fenv_t ): LONGINT; C; EXTERNAL;
  219.  
  220. (*******************************************************************************
  221. *     The function "fesetenv" installs the floating-point environment          *
  222. *     environment represented by the object pointed to by its argument         *
  223. *     "envp".  The value of "*envp" must be set by a call to "fegetenv" or     *
  224. *     "feholdexcept", by an implementation-defined macro of type "fenv_t",     *
  225. *     or by the use of the pointer macro FE_DFL_ENV as the argument.           *
  226. *******************************************************************************)
  227.  
  228. { NB PROCEDURE fesetenv( VAR envp: fenv_t ); C;}
  229. PROCEDURE fesetenv( VAR envp: fenv_t ); C; EXTERNAL;
  230.  
  231. (*******************************************************************************
  232. *     The function "feupdateenv" saves the current exceptions into its         *
  233. *     automatic storage, installs the environment represented through its      *
  234. *     pointer argument "envp", and then re-raises the saved exceptions.        *
  235. *     This function, which supersedes the SANE function "procexit", can be     *
  236. *     used in conjunction with "feholdexcept" to write routines which hide     *
  237. *     spurious exceptions from their callers.                                  *
  238. *******************************************************************************)
  239.       
  240. { NB PROCEDURE feupdateenv( VAR envp: fenv_t ); C;}
  241. PROCEDURE feupdateenv( VAR envp: fenv_t ); C; EXTERNAL;
  242.  
  243. {$IFC GENERATING68K}
  244.  
  245. (*******************************************************************************
  246. *     The following functions provide control of rounding precision.           *
  247. *     Because the PowerPC does not provide this capability, these functions    *  
  248. *     are available only for the 68K Macintosh.  Rounding precision values     *
  249. *     are defined by the rounding precision macros.  These functions are       *
  250. *     equivalent to the SANE functions getprecision and setprecision.          *
  251. *******************************************************************************)
  252.  
  253. FUNCTION fegetprec: LONGINT; C;
  254. FUNCTION fesetprec (precision: LONGINT): LONGINT; C;
  255.  
  256. {$ENDC}
  257.  
  258.  
  259. {$SETC UsingIncludes := fpenvIncludes}
  260.  
  261. {$ENDC} {__FPENV__}
  262.  
  263. {$IFC NOT UsingIncludes}
  264.  END.
  265. {$ENDC}
  266.